/*
 * useChat - 聊天逻辑组合式函数
 * 负责管理消息、建立SSE连接并调用后端聊天接口
 */

import { ref, computed } from 'vue';
import { API_BASE, MESSAGE_STATUS, MESSAGE_TYPE, SENDER } from '../utils/constants';
import { useSSE } from './useSSE';
import { useStorage } from './useStorage';

/**
 * 聊天逻辑入口
 * @returns {{ messages: any, sending: any, send: Function, connect: Function, currentConversationId: any, conversations:any, createNewConversation:Function, switchConversation:Function, renameConversation:Function, deleteConversation:Function, retryMessage:Function }}
 */
export function useChat() {
  // const { connect: connectSSE, on, connectionId } = useSSE();
  const sse = useSSE();
  const { connect: connectSSE, on, abort } = sse;
  const storage = useStorage();

  // 标记是否存在进行中的流式助手消息，及是否需要忽略紧随其后的标准message事件
  const streamingInProgress = ref(false);
  const ignoreNextMessageEvent = ref(false);
  
  // 思考状态标记
  const isThinking = ref(false);
  
  // 初始化状态
  const isInitializing = ref(false);
  
  // 错误状态管理
  const lastError = ref(null);
  const retryCount = ref(0);
  const maxRetries = 3;
  
  /**
   * 显示错误信息
   * @param {string} message - 错误消息
   * @param {Object} error - 错误对象
   */
  function showError(message, error = null) {
    lastError.value = { message, error, timestamp: Date.now() };
    console.error(message, error);
  }
  
  /**
   * 清除错误状态
   */
  function clearError() {
    lastError.value = null;
    retryCount.value = 0;
  }

  /**
   * 当前会话ID（为空表示暂无会话，需用户手动创建）
   */
  const currentConversationId = ref(null);
  /**
   * 当前会话消息列表（当未选择会话时为空数组）
   */
  const messages = ref([]);
  const sending = ref(false);
  
  // 在初始化时主动加载存储数据
  const conversations = ref([]);
  
  /**
   * 初始化聊天数据（从存储恢复，不再自动创建新会话）
   * - 当没有会话时，保持空状态，等待用户手动点击“新建”按钮
   * @returns {Promise<void>} 初始化完成
   */
  async function initializeChatData() {
    if (isInitializing.value) return;
    isInitializing.value = true;
    
    try {
      // 初始化存储并获取会话列表
      await storage.initializeStorage();
      conversations.value = storage.listConversations();
      
      // 当没有任何会话时，不自动创建，保持空状态
      if (conversations.value.length === 0) {
        currentConversationId.value = null;
        messages.value = [];
      } else {
        // 选择最新会话，并优先使用内存消息；若为空则从IndexedDB恢复并赋值给messages
        const latestConv = conversations.value[0];
        currentConversationId.value = latestConv.id;
        let list = storage.listMessages(latestConv.id);
        if (!list || list.length === 0) {
          list = await storage.restoreMessages(latestConv.id);
        }
        messages.value = list;
      }
    } catch (error) {
      console.error('初始化聊天数据失败:', error);
      // 初始化失败时，保持空状态，不自动创建会话
      currentConversationId.value = null;
      conversations.value = [];
      messages.value = [];
    } finally {
      isInitializing.value = false;
    }
  }

  /**
   * 更新最后一条发送中的用户消息状态为已发送
   */
  function updateUserMessageStatus() {
    // 更新内存中的消息状态
    for (let i = messages.value.length - 1; i >= 0; i--) {
      const message = messages.value[i];
      if (message.sender === SENDER.USER && message.status === MESSAGE_STATUS.SENDING) {
        // 使用Vue的响应式更新方式
        messages.value[i] = { ...message, status: MESSAGE_STATUS.SENT };
        // 同时更新存储中的状态
        storage.updateMessageStatus(message.id, MESSAGE_STATUS.SENT);
        break;
      }
    }
  }

  // 监听SSE事件，处理流式文本与最终消息
  on('text_chunk', (data) => {
    if (!data) return;
    
    // 如果是第一次收到文本响应，移除思考中状态
    if (isThinking.value) {
      const thinkingIndex = messages.value.findIndex(m => m.id === 'thinking');
      if (thinkingIndex >= 0) {
        messages.value.splice(thinkingIndex, 1);
      }
      isThinking.value = false;
    }
    
    // 将流式内容聚合到一条"进行中"的助手消息中
    let last = messages.value[messages.value.length - 1];
    if (!last || last.sender !== SENDER.ASSISTANT || last.status === MESSAGE_STATUS.SENT) {
      last = { id: 'streaming', sender: SENDER.ASSISTANT, content: '', status: MESSAGE_STATUS.SENDING, type: MESSAGE_TYPE.TEXT };
      messages.value.push(last);
      streamingInProgress.value = true;
    }
    last.content += data.content || '';
    if (data.isComplete) {
      last.status = MESSAGE_STATUS.SENT;
      // 流式完成后，写入存储并替换占位消息，避免随后标准message事件重复追加
      const saved = storage.addMessage(currentConversationId.value, {
        sender: SENDER.ASSISTANT,
        content: last.content,
        status: MESSAGE_STATUS.SENT,
        type: MESSAGE_TYPE.TEXT
      });
      messages.value[messages.value.length - 1] = saved;
      streamingInProgress.value = false;
      ignoreNextMessageEvent.value = true;
      
      // 确保用户消息状态更新为已发送
      updateUserMessageStatus();
      
      // 重置发送状态，允许用户继续输入
      sending.value = false;
    }
  });

  on('message', (data) => {
    if (!data) return;
    // 如果前面刚完成过一次流式响应，则忽略这次标准message以避免重复
    if (ignoreNextMessageEvent.value) {
      ignoreNextMessageEvent.value = false;
      return;
    }
    if (data.type === 'assistant') {
      // 移除思考中状态（如果存在）
      if (isThinking.value) {
        const thinkingIndex = messages.value.findIndex(m => m.id === 'thinking');
        if (thinkingIndex >= 0) {
          messages.value.splice(thinkingIndex, 1);
        }
        isThinking.value = false;
      }
      
      const saved = storage.addMessage(currentConversationId.value, {
        sender: SENDER.ASSISTANT,
        content: data.content,
        status: MESSAGE_STATUS.SENT,
        type: MESSAGE_TYPE.TEXT
      });
      messages.value.push(saved);
      
      // 重置发送状态，允许用户继续输入
      sending.value = false;
    }
  });

  // 工具调用开始：只显示思考中状态，不显示具体工具调用信息
  on('tool_call_start', (data) => {
    try {
      // 设置思考状态
      isThinking.value = true;
      
      // 如果没有思考中的消息，则添加一个
      const existingThinking = messages.value.find(m => m.id === 'thinking');
      if (!existingThinking) {
        messages.value.push({
          id: 'thinking',
          sender: SENDER.ASSISTANT,
          content: '思考中...',
          status: MESSAGE_STATUS.SENDING,
          type: MESSAGE_TYPE.TEXT
        });
      }
    } catch (_) { /* noop */ }
  });

  // 工具调用结果：移除思考中状态，不显示工具调用结果
  on('tool_call_result', (data) => {
    try {
      // 工具调用完成，可以继续思考或准备返回最终结果
      // 这里不做任何显示，等待最终的文本响应
    } catch (_) { /* noop */ }
  });

  on('status', (data) => {
    // 可根据需要展示状态提示（暂不入库）
  });

  on('error', (err) => {
    // 移除思考中状态
    if (isThinking.value) {
      const thinkingIndex = messages.value.findIndex(m => m.id === 'thinking');
      if (thinkingIndex >= 0) {
        messages.value.splice(thinkingIndex, 1);
      }
      isThinking.value = false;
    }
    
    // 更详细的错误处理
    let errorMessage = '发生未知错误，请稍后重试。';
    if (err?.message) {
      if (err.message.includes('network') || err.message.includes('fetch')) {
        errorMessage = '网络连接异常，请检查网络后重试。';
      } else if (err.message.includes('timeout')) {
        errorMessage = '请求超时，请稍后重试。';
      } else if (err.message.includes('server')) {
        errorMessage = '服务器错误，请稍后重试。';
      }
    } else if (err?.error === 'SSE连接错误') {
      // 处理SSE特定错误
      if (err.readyState === EventSource.CONNECTING) {
        errorMessage = '正在连接服务器，请稍候...';
      } else if (err.readyState === EventSource.CLOSED) {
        errorMessage = '与服务器的连接已断开，请刷新页面重试。';
      } else {
        errorMessage = 'SSE连接错误，请检查网络连接和服务器状态。';
      }
    }
    
    showError(errorMessage, err);
    
    // 添加错误消息到聊天记录
    messages.value.push({ 
      id: 'error-' + Date.now(),
      sender: SENDER.ASSISTANT, 
      content: errorMessage, 
      status: MESSAGE_STATUS.FAILED, 
      type: MESSAGE_TYPE.TEXT,
      isError: true
    });
    sending.value = false;
  });

  /**
   * 建立SSE连接
   * @returns {Promise<void>} 连接建立完成
   */
  async function connect() {
    await connectSSE();
  }

  /**
   * 发送消息到后端
   * @param {string} text - 用户消息文本
   * @returns {Promise<void>} 发送完成
   */
  async function send(text) {
    if (!text) return;
    // 若尚未选择/创建会话，则阻止发送
    if (!currentConversationId.value) {
      lastError.value = new Error('请先新建对话后再发送消息');
      sending.value = false;
      return;
    }
    sending.value = true;

    // 本地插入并持久化用户消息为发送中
    const userMsg = {
      sender: SENDER.USER,
      content: text,
      status: MESSAGE_STATUS.SENDING,
      type: MESSAGE_TYPE.TEXT
    };
    const savedUser = storage.addMessage(currentConversationId.value, userMsg);
    messages.value.push(savedUser);

    // 使用带重试机制的发送方法
    await sendWithRetry(text);
    
    // 更新用户消息状态为已发送（如果没有错误）
    if (!lastError.value) {
      const index = messages.value.findIndex(m => m.id === savedUser.id);
      if (index !== -1) {
        messages.value[index] = { ...savedUser, status: MESSAGE_STATUS.SENT };
        storage.updateMessageStatus(savedUser.id, MESSAGE_STATUS.SENT);
      }
    }
  }
  
  /**
   * 带重试机制的发送消息
   * @param {string} text - 用户消息文本
   * @param {boolean} isRetry - 是否为重试
   * @returns {Promise<void>} 发送完成
   */
  async function sendWithRetry(text, isRetry = false) {
    if (!isRetry) {
      clearError(); // 新消息时清除之前的错误
      retryCount.value = 0;
    }
    
    try {
      await fetch(`${API_BASE}/chat/message`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          message: text,
          conversationId: currentConversationId.value,
          connectionId: sse.connectionId
        })
      });
      
      // 请求成功，清除错误状态
      clearError();
      
    } catch (error) {
      // 判断是否可以重试
      if (retryCount.value < maxRetries) {
        retryCount.value++;
        showError(`发送失败，正在重试中... (${retryCount.value}/${maxRetries})`, error);
        
        // 延迟重试
        setTimeout(() => {
          sendWithRetry(text, true);
        }, 1000 * retryCount.value); // 递增延迟
        
      } else {
        // 超过最大重试次数
        let errorMessage = '发送失败，请检查网络连接后重试。';
        if (error.message?.includes('timeout')) {
          errorMessage = '请求超时，请稍后重试。';
        } else if (error.message?.includes('server')) {
          errorMessage = '服务器异常，请稍后重试。';
        }
        
        showError(errorMessage, error);
        
        // 更新用户消息状态为失败
        const lastUserMsg = messages.value.slice().reverse().find(m => m.sender === SENDER.USER && m.status === MESSAGE_STATUS.SENDING);
        if (lastUserMsg) {
          const index = messages.value.findIndex(m => m.id === lastUserMsg.id);
          if (index !== -1) {
            messages.value[index] = { ...lastUserMsg, status: MESSAGE_STATUS.FAILED };
            storage.updateMessageStatus(lastUserMsg.id, MESSAGE_STATUS.FAILED);
          }
        }
        
        // 添加错误提示消息
        messages.value.push({ 
          id: 'error-' + Date.now(),
          sender: SENDER.ASSISTANT, 
          content: errorMessage + ' 您可以点击重试按钮重新发送。', 
          status: MESSAGE_STATUS.FAILED, 
          type: MESSAGE_TYPE.TEXT,
          isError: true
        });
        
        // 重置发送状态
        sending.value = false;
      }
    }
  }

  // 维护会话列表（优先内存，后台恢复）
  // const conversations = ref(storage.listConversations()); // 移除此行，因为已在上面定义
  
  /**
   * 刷新会话列表（从存储层重新获取）
   * @returns {Array} 最新会话列表
   */
  function refreshConversations() {
    conversations.value = storage.listConversations();
    return conversations.value;
  }
  
  /**
   * 创建新会话并切换到新会话
   * @param {string} [title] - 新会话标题
   * @returns {{id:string, title:string}} 新创建的会话对象
   */
  function createNewConversation(title = '新对话') {
    const conv = storage.createConversation(title);
    currentConversationId.value = conv.id;
    messages.value = storage.listMessages(conv.id);
    // 后台恢复消息（通常为空，但保持一致）
    storage.restoreMessages(conv.id);
    refreshConversations();
    return conv;
  }
  
  /**
   * 切换当前会话
   * @param {string} id - 目标会话ID
   * @returns {Promise<void>} 切换完成
   */
  async function switchConversation(id) {
    if (!id || id === currentConversationId.value) return;
    
    // 立即更新当前会话ID
    currentConversationId.value = id;
    
    // 先尝试从内存获取消息
    let messageList = storage.listMessages(id);
    
    // 如果内存中没有消息，立即从IndexedDB恢复
    if (!messageList || messageList.length === 0) {
      messageList = await storage.restoreMessages(id);
    }
    
    // 更新消息列表（确保响应式更新）
    messages.value = messageList;
    
    // 确保IndexedDB中的数据已恢复到内存（后台保证数据一致性）
    if (messageList.length > 0) {
      // 如果已有消息，后台再次恢复确保数据同步
      storage.restoreMessages(id);
    }
  }
  
  /**
   * 重命名会话
   * @param {string} id - 会话ID
   * @param {string} title - 新标题
   * @returns {void}
   */
  function renameConversation(id, title) {
    if (!id || !title) return;
    storage.setTitle(id, title);
    refreshConversations();
  }
  
  /**
   * 删除会话（若删除当前会话，则切换至最新会话；若无会话则不再自动创建）
   * @param {string} id - 会话ID
   * @returns {Promise<boolean>} 是否删除成功
   */
  async function deleteConversation(id) {
    if (!id) return false;
    const ok = await storage.deleteConversation(id);
    refreshConversations();
    if (id === currentConversationId.value) {
      const list = conversations.value;
      if (list && list.length) {
        currentConversationId.value = list[0].id;
        messages.value = storage.listMessages(currentConversationId.value);
        await storage.restoreMessages(currentConversationId.value);
      } else {
        // 不自动创建新会话，保持空状态，等待用户手动创建
        currentConversationId.value = null;
        messages.value = [];
      }
    }
    return ok;
  }

  /**
   * 中断当前对话
   */
  function abortChat() {
    // 停止SSE连接
    if (abort) {
      abort();
    }
    
    // 移除思考中状态
    if (isThinking.value) {
      const thinkingIndex = messages.value.findIndex(m => m.id === 'thinking');
      if (thinkingIndex >= 0) {
        messages.value.splice(thinkingIndex, 1);
      }
      isThinking.value = false;
    }
    
    // 重置发送状态
    sending.value = false;
    streamingInProgress.value = false;
  }

  /**
   * 重试发送指定的用户消息
   * @param {string} messageId - 需要重试的消息ID
   */
  async function retryMessage(messageId) {
    const msg = messages.value.find(m => m.id === messageId);
    if (!msg || msg.sender !== SENDER.USER) return;
    msg.status = MESSAGE_STATUS.SENDING;
    await fetch(`${API_BASE}/chat/message`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        message: msg.content,
        conversationId: currentConversationId.value,
        connectionId: sse.connectionId
      })
    }).then(() => {
      msg.status = MESSAGE_STATUS.SENT;
    }).catch(() => {
      msg.status = MESSAGE_STATUS.FAILED;
    });
  }

  return { 
    messages, 
    sending, 
    send, 
    connect, 
    currentConversationId, 
    conversations, 
    createNewConversation, 
    switchConversation, 
    renameConversation, 
    deleteConversation, 
    retryMessage,
    abortChat,
    isThinking,
    isInitializing,
    initializeChatData,
    lastError,
    clearError,
    retryCount
  };
}